\noindent
This section lists a series of experiments on which the capabilities of the system were tested.
In all the experiments described in this chapter, the selection filter process removes a third of the
genotypes alive at the beginning of each generation. Other parameters are set individually for
each experiment, and we provide the user supplied values at the beginning of the experiment's description
in the following format:
\begin{verbatim}
    maxGeneComp = 55
    maxComp = 5000
    geneDifference = 12
    populationDefaultSize = 200
    \end{verbatim}
Where {\em maxGeneComp} indicates the maximum complexity size of an allele, {\em maxComp} is the maximum
total complexity size of the gene pool, {\em geneDifference} is the value that measures the ``difference" factor
that must hold in between alleles and \populationDefaultSize{} is the number of genotypes that are evaluated
(marked as `Alive') in each generation.

\MySection{Boolean Functions}\label{BooleanFunctions}
\input{BooleanDef}


\MySection{Lists and Lists Operations}
We experimented with lists of integers using the type:
\begin{equation}
 TyList\MyDef\Pi X . \AT{X}{\AT{(\AT{Int}{\AT{X}{X}})}{X}}
\end{equation}
All results in this section were obtained using context \ref{ListInt}:
\begin{context}
\begin{verbatim}
/*Types*/
TyList = TT X . X -> (TyInt->X->X)->X;

/*List constructors*/
empty_list = Lam X . lam x : X . lam y : TyInt->X->X . x;
cons =  lam elt : TyInt .
        lam lst : TyList .
        Lam X . lam x : X . lam y : TyInt->X->X . y elt (lst [X] x y);

/*Operations$
plus : TyInt->TyInt->TyInt;
mult : TyInt->TyInt->TyInt;
minus : TyInt->TyInt->TyInt;
div : TyInt->TyInt->TyInt;

/*First order objects*/
zero : TyInt;
one : TyInt;
ten : TyInt;
\end{verbatim}
\caption{$ListInt$}\label{ListInt}
\end{context}
\noindent
The ABGP system is able to consistently evolve a solution to the following problems within
3000 genotype evaluations with 99\% probability (computed out of 150 runs for each problems). For each of these problems,
the parameters were fixed at \maxComp = 5000 units, \populationDefaultSize = 3000, \maxGeneComp=45 and \geneDiff=15. All the solutions evolved work for arbitrary list size and the exact same system was used to evolve all of the solutions. The only difference between the runs were the lists of test cases passed as input.

\subsection{Summing the Elements of a List of Numbers}
\noindent In this problem, we evolve a program that adds recursively
the elements of a list of numbers, returning $0$ if the list is
empty. In this case, the ABGPS is always able to always find a
solution to this problem within 300 evaluations.
\subsubsection{Solution example}
Example of solution program:
\begin{samepage}
\begin{verbatim}
(/* Type = TyInt-> (TT E. E-> (TyInt-> E-> E)-> E)-> TyInt --
    ID = 3*/ lam n:TyInt.lam r:TyList.r [TyInt] n plus)
((/* Type = (TT W. W-> (TyInt-> W-> W)-> W)-> TyInt--
    ID = 17*/ lam o:TyList.o [TyInt] 0 mult)
(/* Type = TT C. C-> (TyInt-> C-> C)-> C--
    ID = 0*/Lam D.lam j:D.lam u:TyInt-> D-> D.j))
\end{verbatim}
\end{samepage}
Corresponding to the normalized term:
\begin{equation}\label{gsxhewd67}
\la{h}{TyList}.h\ \typ{TyInt}\ zero\ plus
\end{equation}
%MODIFICATION_A why are solutions so short
This is a short solution, but the reader must keep in mind that this is the {\em normalized term corresponding to the solution}. The solution that the GP produced is in fact longer but gets compacted when normalized. The solution in this case belongs to the species depicted in figure \ref{Species23th}.
\begin{figure}[h]
\centering \epsfig{file=SpeciesListAdd.eps, width=80mm}
\caption{Species to which the example program that normalizes to
\ref{gsxhewd67} belongs} \label{Species23th}
\end{figure}

\subsection{Multiplying the Elements of a List of Numbers}
\noindent Our system is able to evolve a program that recursively
multiplies all the elements of a list of numbers and returns $1$ if
the list is empty. In this case as in the others, the size of the
list is arbitrary. To evolve this program, we use the list of 7 test
cases below:
\begin{verbatim}
Arg (List of Int),Result
cons 0 (cons 6 empty_list),0
cons 4 (cons 6 empty_list),24
cons 2 (cons 2 (cons 2 empty_list)),8
cons 2 (cons 5 (cons 2 empty_list)),20
\end{verbatim}
\subsubsection{Solution example}
Example of solution program:
\begin{verbatim}
    (/*
    Type = (((TT W. W-> (Int-> W-> W)-> W)-> Int)->
    (TT N. N-> (Int-> N-> N)-> N)-> Int)->
    (TT V. V-> (Int-> V-> V)-> V)-> Int-- ID = 0
    */
    lam s:((TT H. H-> (Int-> H-> H)-> H)-> Int)-> (TT Q. Q-> (Int->
    Q-> Q)-> Q)-> Int.s (lam t:TyList.t [Int] 1 mult))

    (/*
    Type = ((TT T. T-> (Int-> T-> T)-> T)-> Int)->
    (TT H. H-> (Int-> H-> H)-> H)-> Int-- ID = 0*/
    lam p:(TT S. S-> (Int-> S-> S)-> S)-> Int.p)
\end{verbatim}
Corresponding to the term:
\begin{equation}
\la{n}{TyList}.n \ \typ{Int}\ one\ mult
\end{equation}
This program belongs to the species illustrated by figure \ref{Species23point5th}
\begin{figure}
\centering \epsfig{file=Species23point5th.eps, width=100mm}
\caption{Species to which the solution listed for the parity of a list problem belongs}
\label{Species23point5th}
\end{figure}

\subsection{Finding the Length of a List of Numbers}
We are able to evolve a program that returns the number of elements of a list of numbers ($0$ if empty) passed as its argument
within 10 generations using these parameters:
\begin{verbatim}
    maxGeneComp = 55
    maxComp = 5000
    geneDifference = 12
    populationDefaultSize = 1000
    \end{verbatim}

\subsubsection{Solution example}
Below is an example solution:
\begin{equation}\label{gsxhewdty56}
\la{d}{TyList}.d\ \typ{Int}\ zero\ (\la{j}{Int}.\la{k}{Int}.plus\ k\ 1)
\end{equation}

\begin{figure}
\centering \epsfig{file=SpeciesListCount.eps, width=100mm}
\caption{Species to which the example program that normalizes to \ref{gsxhewdty56} belongs}
\label{Species24th}
\end{figure}

\subsection{Parity of List Size}
\noindent
We are able to always evolve, within 15 generations, a program that takes a list of numbers as its only argument and returns $1$ if the size of the list is even and $0$ otherwise (the program returns $1$ if the list is only composed of the $\mathit{empty\_list}$). To evolve this program, we use the following list of test cases:
\begin{verbatim}
Arg (List of Int), Result
cons 6 empty_list,0
cons 4 (cons 6 empty_list),1
cons 2 (cons 2 (cons 2 empty_list)),0
empty_list,1
cons 89 (cons 2 (cons 0 empty_list)),0
cons 0 (cons 2 (cons 0 empty_list)),0
cons 3 (cons 0 (cons 2 (cons 0 empty_list))), 1
\end{verbatim}
with the set-up:
\begin{verbatim}
    maxGeneComp = 55
    maxComp = 5000
    geneDifference = 12
    populationDefaultSize = 1000
    \end{verbatim}
\subsubsection{Solution example}
\noindent
Example of solution program:
\begin{verbatim}
(/* Type = Int-> (TT T. T-> (Int-> T-> T)-> T)-> Int--
    ID = 1*/ lam n:Int.lam l:TyList.l [Int] n (lam x:Int.lam u:Int.minus 1 u))
((/* Type = Int-> Int--
    ID = 4*/ lam f:Int.f)
(/* Type = Int--
    ID = 0*/ one))
\end{verbatim}
Corresponding to the term:
\begin{equation}\label{ParityPblm}
\la{x}{TyList}.x\ [Int]\ 1\ (\la{w}{Int}.\la {y}{Int}.minus\ 1\ y)
\end{equation}
This phenotype belongs to the species depicted in figure
\ref{Species27th}
\begin{figure}
\centering \epsfig{file=Species27th.eps, width=100mm}
\caption{Species to which the solution for the list parity problem
belongs (term \ref{ParityPblm})} \label{Species27th}
\end{figure}

%  \subsection{$N^{TH}$ Element}
%  \noindent
%  Program takes two arguments: an integer $n$ and a list $L$. It returns the $n^{th}$ element of $L$. If  the value of $n$  is less than 1, it returns  the first element of  the list otherwise if the value of $N$ is greater than the length of $L$, it returns the last element of $L$.
%   \subsubsection{Solution example}
\noindent
%Example of solution program:
%\begin{verbatim}
%(/* Type = Int-> (TT T. T-> (Int-> T-> T)-> T)-> Int-- ID = 1*/
%lam n:Int.lam l:TyList.l [Int] n (lam x:Int.lam u:Int.minus 1 u))
%((/* Type = Int-> Int-- ID = 4*/lam f:Int.f)
%(/* Type = Int-- ID = 0*/one))
%\end{verbatim}
%Corresponding to the term:
%\begin{equation}
%\la{x}{TyList}.x\ [Int]\ 1\ (\la{w}{Int}.\la y:Int.minus\ 1\ y)
%\end{equation}
%Belonging to species as per figure \ref{Species27th}
%\begin{figure}
%\centering \epsfig{file=Species28th.eps, width=100mm}
%\caption{Species to which solution belongs}
%\label{Species28th}
%\end{figure}


\MySection{Trees and Tree Operations}
We experimented with binary trees of integer as represented by the type:
\begin{equation}
 TyTree\MyDef\Pi X . \AT{(\AT{Int}{\AT{Int}{\AT{Int}{X}}})}{\AT{(\AT{Int}{\AT{X}{\AT{X}{X}}})}{X}}
\end{equation}
All results in this section were obtained using context
\ref{treeCtx}.

\begin{context}[h]
{\small
\begin{verbatim}
/*Types*/
TyBool = TT X . X -> X ->X;
TyTree = TT X .(Int->Int->Int->X)->(Int->X->X->X)->X;

/*Boolean terms*/
true  = Lam X . lam x : X . lam y : X . x;
false = Lam X . lam x : X . lam y : X . y;

/*Tree construction terms*/
branch = lam a : Int .
         lam b : Int .
         lam c : Int .
         Lam X . lam x : Int->Int->Int->X .
                 lam y : Int->X->X->X . x a b c;

stem =   lam a : Int .
         lam b : TyTree .
         lam c : TyTree .
         Lam X . lam x : Int->Int->Int->X .
                 lam y : Int->X->X->X . y a (b [X] x y) (c [X] x y);

/*Binary arithmetics*/
plus : Int->Int->Int;
mult : Int->Int->Int;
minus : Int->Int->Int;
div : Int->Int->Int;

/*Comparison*/
gt : Int->Int->TyBool;

/*Numerical Constants*/
zero : Int;
one : Int;
ten : Int;
\end{verbatim}}
\caption{The tree context}\label{treeCtx}
\end{context}
\noindent
For example, \ref{tree01} is the binary tree of type $\typ{TyTree}$ that normalizes to \ref{tree02}.
\begin{equation}\label{tree01}
\begin{array}{l}
stem\ 0\ (branch\ 7\ 6\ 8)\ (branch\ 3\ 1\ 4)
\end{array}
\end{equation}
\begin{equation}\label{tree02}
\begin{array}{l}
\Lambda X . \la{x}{\AT{Int}{\AT{Int}{\AT{Int}{X}}}} . \la{y}{\AT{Int}{\AT{X}{\AT{X}{X}}}} . y\ 0\ (x\ 7\ 6\ 8)\ (x\ 3\ 1\ 4)
\end{array}
\end{equation}
An abstract representation of this tree is depicted in figure \ref{btree1}
\begin{figure}
\centering \epsfig{file=BinaryTree.eps, width=100mm}
\caption{The object of type $\typ{TyTree}$ corresponding to \ref{tree01}}
\label{btree1}
\end{figure}

\subsection{Path that Results in the Maximum Node Sum}
In this problem, we evolve a program that discovers the maximum sum
path in a tree. For example, in tree \ref{tree02}, the maximum sum
path is $0+7+8 = 15$. To evolve this program, we used the list of 5
test cases, listed below:
{\small \begin{verbatim}
Arg (Tree of Int), Result (Int)
(stem 0 (branch 7 6 8) (branch 3 1 4)), 15
(stem 1 (branch 7 4 8) (stem 3 (branch 14 15 16)(branch 3 1 4))),34
(stem 1 (branch 1 4 8) (stem 3 (branch 9 1 6)(branch 3 1 4))), 19
(stem 1 (stem 5 (branch 1 4 8)(branch 9 4 8)) (stem 3 (branch 9 1 6)(branch 3 1 4))),23
(stem 0 (stem 5 (branch 1 4 2)(branch 4 4 8)) (stem 3 (branch 2 1 6)(branch 3 1 4))),17
\end{verbatim}}
Our system consistently finds a solution. Below is an example of a solution program:
\begin{samepage}
\begin{verbatim}
    (/* Type =  (Int-> Int-> Int-> Int)->
                (TT X. (Int-> Int-> Int-> X)-> (Int-> X-> X -> X)-> X)-> Int--
    ID = 4*/ lam y:Int-> Int-> Int-> Int.lam j:TyTree.j [Int] y y)
    ((/* Type = (Int-> Int-> Int)-> Int-> Int-> Int-> Int--
    ID = 6*/lam i:Int-> Int-> Int.lam r:Int.lam h:Int.lam h':Int.plus r (i h h'))
    (/* Type = Int-> Int-> Int--
    ID = 2*/lam h:Int.lam j:Int.gt h j [Int] h j))
\end{verbatim}
\end{samepage}
Corresponding to the term:
\begin{equation}\label{treesol}
\begin{array}{l}
\la{x}{TyTree}.x\ [Int]\\
\ \ \ \ \ \ \ \ \ \ \ \ (\la{k}{Int}.\la{v}{Int}.\la{g}{Int}.plus\ k\ (gt\ v\ g\ [Int]\ v\ g))\\
\ \ \ \ \ \ \ \ \ \ \ \ (\la{w}{Int}.\la{t}{Int}.\la{y}{Int}.plus\ w\ (gt\ t\ y\ [Int]\ t\ y)))
 \end{array}
\end{equation}
The solution in this case belongs to the species depicted by figure \ref{btree1sol1}.
\begin{figure}[h]
\centering \epsfig{file=SpeciesTreeProblem1.eps, width=\linewidth}
\caption{The species of the solution program corresponding to the term of \ref{treesol}}
\label{btree1sol1}
\end{figure}

\MySection{Strings and List of
Characters}\label{String_Lists_Operations} We experimented with
strings (strings were built in the system) and lists of strings
using context \ref{ListStr2}.
\begin{context}[h]
{\small
\begin{verbatim}
/*******************************
Context ListStr for strings and list of strings programs
********************************/

TyList = TT X . X -> (String->X->X)->X;
TyBool = TT X . X -> X ->X;

true = Lam X . lam x : X . lam y : X . x;
false = Lam X . lam x : X . lam y : X . y;

empty_list = Lam X . lam x : X . lam y : String->X->X . x;
cons = lam elt : String . lam lst : TyList .
    Lam X . lam x : X . lam y : String->X->X . y elt (lst [X] x y);

empty_string = "";

length : String->Int;
concat : String->String->String;
compstr : String -> String -> TyBool;
substr : String -> Int -> Int -> String;
\end{verbatim}}
\caption{$ListStr$, a context for evolving list
operations}\label{ListStr2}
\end{context}
\noindent
so that for example,
\begin{verbatim}
(cons "dsds" (cons "jk" empty_list))
\end{verbatim}
normalizes to:
\begin{verbatim}
(Lam H.lam o:H.lam k:String-> H-> H.k "dsds" (k "jk" o))
\end{verbatim}

\noindent
We easily evolve a list concatenation operation using only the following 2 test cases:
\begin{verbatim}
Arg (List of Strings), Result
(cons "hsja" (cons "hsj" (cons "ty" empty_list))), "hsjahsjty"
empty_list,empty_string
\end{verbatim}
The programs evolved correspond usually (with some exceptions) to the term:
\begin{equation}
\la{x}{TyList}.x\ [String]\ empty\_string\ concat
\end{equation}



\MySection{the ant cooperation evolution system}\label{AntCoopEvo}

    \noindent
    Ant problems are typical in evolutionary computation. We tested ABGP's potential to evolve
    such systems using the following variables:
    \begin{verbatim}
    maxGeneComp = 55
    maxComp = 5000
    geneDifference = 12
    populationDefaultSize = 200
    \end{verbatim}
    
%MODIFICATION_A diagram
\begin{figure}[h]
\centering \epsfig{file=antInterafce.eps, width=100mm}
\caption{The ant cooperation problem interface. The bright red pixel represents an ant carrying food. The other two brown pixels are ants looking for food. The dark green square is the nest and the green patches are the food}
\label{antInterafce}
\end{figure}


    \noindent
    In this experiment, 8 ants, guided by the rules of their common genotype are evaluated
    in a 2-dimensional environment (see figure \ref{antInterafce}) for 200 time units. At the beginning of each evaluation run,
    the environment contains $60$ particles of food. Ants must pick up
    food and carry it back home. They can
    ``communicate" with each other using pheromones, which they can
    drop in the environment. The scent that is given by the pheromones
    decay as time ticks on. 
    %MODIFICATION_A pheromone update
    Pheromones are implemented as real numbers (between 0 and 1.0). Once a pheromone is placed on the grid, its value is divided by two at each click, and it is removed when its value is below 0.00001. 
    %MODIFICATION_A work availible
    The source code and win32 executable built for this experiment is available online at:
    \url{http://code.google.com/p/gene-centered-ecosystem-framework-gp/source/browse/trunk#trunk/doc/franck binard PhD thesis/experimental/system_ants}. For this experiment, we used context \ref{AntCtx}. Genotypes evaluate to programs of type $Behavior$.
\begin{context}[h]
\begin{verbatim}
/*Types*/
TyBool = TT X . X->X->X;
Direction;
Behavior;

/*Sensing and acting*/
left : Direction;
right : Direction;
front : Direction;
random : Direction;
home : Direction;
move : Direction -> Behavior;
facingHome : TyBool;
onFood : TyBool;
amHome : TyBool;
amLoaded : TyABool;

detectMarker : TT X . (Direction -> X) -> X -> X ;
detectFood : TT X . (Direction -> X) -> X -> X ;

dropFood : Behavior;
pickupFood : Behavior;
dropMarker : Behavior;
goHome : Behavior;
turnAround : Behavior;

\end{verbatim}
\caption{$AntCtx$}\label{AntCtx}
\end{context}

\subsection{Procedure}
\noindent
Each of the 8 ants guided by their genotype behavior is ``executed" in sequence for each genotype. The genotype's fitness is computed as the number of food particles that the family managed to bring back home (from 0 to 60) plus a token score (.5) simply for not producing a run time error. Run time
errors might be caused, for example, by a call to the {\em dropFood} function by an ant that is not carrying any food. The following genotype:
\begin{figure}[h]
\centering \epsfig{file=antSpecies1.eps, width=100mm}
\caption{Species of genotype example for ant problem} \label{antSpecies1}
\end{figure}
\begin{verbatim}
/* Type = Behavior-- ID = 42*/
    detectMarker [Behavior] move
        (amLoaded [Behavior] (amHome [Behavior] dropFood (moveA home))
        (onFood [Behavior] pickupFood (detectFood [Behavior] moveA
        (detectMarker [Behavior] moveA (moveA (facingHome [DirectionA]
        right random))))))
\end{verbatim}
is an example of a one allele (type $\typ{Behavior}$) complete program. Its fitness was measured
at 26.5 but it would vary in different environments. The next genotype:
\begin{verbatim}
(/* Type = Behavior-> Behavior-- ID = 1*/
    detectFood [Behavior] (lam s:DirectionA.moveA s))
(((/* Type = (DirectionA-> Behavior)-> Behavior-> Behavior-- ID = 1*/
    detectFood [Behavior])
(/* Type = DirectionA-> Behavior-- ID = 0*/moveA))
(/* Type = Behavior-- ID = 0*/
    amLoaded [Behavior]
    (amHome [Behavior] dropFood (moveA home))
    (onFood [Behavior] pickupFood (detectFood [Behavior] moveA
    (detectMarker [Behavior] moveA (moveA (facingHome [DirectionA] right random)))))))
\end{verbatim}
is a 4 alleles genotype, that scored 13.5. It belongs to the species depicted in figure \ref{antSpecies1}.
Figure \ref{chartAnt1} plots the average fitness changes over 10 generations for 50 runs.
\begin{figure}[h]
\centering \epsfig{file=chartAnt.eps, width=100mm}
\caption{Species of genotype example for ant problem} \label{chartAnt1}
\end{figure}





%MODIFICATION_A_B_D added discussion section
\MySection{Discussion}
In this section, the results presented above are discussed. 

\subsection{Importance of \maxGeneComp{} Value}\label{maxgenecompimotance}
Our results indicate a strong relationship between the average size
of alleles and their performance. Our data for this set of problems
strongly suggests that allowing larger alleles reduces performance
when the maximum total size of the gene pool remains constant. This
is illustrated by figure \ref{TableAAA} which describes the results
obtained by solving each of the three problems at different values
of \maxGeneComp{} 50 times for a maximum of 20 generations. However,
when genes above a certain size are not allowed, it becomes
impossible to derive genes capable of expressing some computations
above a threshold of complexity. When this happens, solutions become
again harder to come by as the evolution process needs to compensate
by creating species that use many very small genes to express the
computation. For the $xor$ function for example, the optimum value
seems to be around $45$ units.
\begin{figure}[h]
\centering \epsfig{file=TableAAA.eps, width=100mm}
\caption{Relationship between average number of evaluation to either a maximum of 20 generations (equivalent to 20000 genotype evaluations) or to solution discovery and maximum size of genes in gene pool for each of the three boolean functions evolved.  Each data point was obtained as the average of 50 runs. The settings for the system that do not vary are:
\maxComp = 1500 units,
\populationDefaultSize = 1000}
\label{TableAAA}
\end{figure}

%MODIFICATION_A allele size distribution
\subsubsection{Allele Size Distribution}
\noindent
In an effort to obtain a sense of the distribution of allele sizes in the gene pool, we set up a variant of our implementation specifically for this purpose (we named it system 1). System 1 only evolves solutions to the $xor$ problem. We provide the code and win32 executable for experimental system 1 online so that our results may be reproduced. It is available at the following address:\\ \url{http://code.google.com/p/gene-centered-ecosystem-framework-gp/source/browse/trunk#trunk/doc/franck binard PhD thesis/experimental/system_1}. Figure \ref{allele_size_distribution_1} displays the size distribution of the alleles after one generation of a system 1 run when \maxGeneComp{} is set at 80 units of complexity. At the measurement point, there are 143 alleles in the gene pool and the mean allele fitness is 1.32 (out of a maximum of 4). Most alleles measure between between 60 and 80 units of complexity. We then repeated the experiment with \maxGeneComp{} set at 300 units of complexity. After 1 generation, there are only 85 alleles in the gene pool and the mean allele fitness is now only 0.73 (a substantial decrease in allele quality). Moreover, big alleles didn't survive the filter process as illustrated by the allele size distribution diagram (\ref{allele_size_distribution_2}). In fact, this version of the gene pool actually contains smaller alleles that the previous version, indicating that large low-quality alleles consumed most of the gene pool's capacity before being destroyed because of their low performance. 


\begin{figure}[h]
\centering \epsfig{file=allele_size_distribution_diag.eps, width=100mm}
\caption{Distribution of allele size in gene pool after one generation when \maxGeneComp{} is set at 80 units of complexity. Results obtained using system 1. 
The settings for the system were:
\maxComp = 7000 units,
\populationDefaultSize = 4000}
\label{allele_size_distribution_1}
\end{figure}


\begin{figure}[h]
\centering \epsfig{file=allele_size_distribution_diag300.eps, width=100mm}
\caption{Distribution of allele size in gene pool after one generation when \maxGeneComp{} is set at 300 units of complexity. Results obtained using system 1.
The settings for the system were:
\maxComp = 7000 units,
\populationDefaultSize = 4000}
\label{allele_size_distribution_2}
\end{figure}






\subsection{Effect of Diversity Generating Measures on the Gene Pool}\label{diversGene}
\begin{samepage}
\noindent
We've already mentioned that using the OCaml built-in
$hash$ function, it is possible to compare the terms contained
within genes by structure. The function takes a parameter $depth$ up
to which it compares structures. If two structures are similar (up
to depth), the function returns the same value for both. The
application of this method to differentiate genes results in the
system's increased ability to make proper use of larger genes
(around 60 units of complexity) to evolve solutions faster and more
reliably. This demonstrates that diversity at the level of blocks
has an important role to play in a modular GP system. Figure
\ref{TableAAC} presents the results of our experimentation with
diversity at the gene level.
\begin{figure}[h]
\centering \epsfig{file=TableAAC.eps,  width=80mm}
\caption{Relationship between average number of evaluation to either
a maximum of 20 generations (equivalent to 20000 genotype
evaluations) or to solution discovery, compared to the maximum size
of genes in gene pool and to the hash differentiation factor for the
evolution of the xor boolean function.  Each data point was obtained
as the average of 50 runs. The settings for the system that do not
vary are: \maxComp = 1500 units, \populationDefaultSize = 1000}
\label{TableAAC}
\end{figure}
\end{samepage}
\subsection{Effect of Size of Genotype Population vs Size of Gene Pool}
\begin{samepage}
\noindent
The number of genotypes in a given population is not as much
of a factor as the allowed size of gene pool. Figure \ref{TableAAB}
shows the results obtained when comparing different size populations
against different size gene pools when the maximum size of genes is
kept fixed  (55 units maximum gene size, hash diversity value of
10).
\begin{figure}[h]
\centering \epsfig{file=TableAAB.eps, width=80mm}
\caption{Relationship between average number of generations to
convergence to solution and size of genotype population and maximum
size of gene pool. Gene Pool Maximum Size of Individual Genes = 55
units, problem is xor, hash differentiator is set at 10}
\label{TableAAB}
\end{figure}
\end{samepage} 
 